package futbol.tacticas.concursantes.TacticaMayanBeserk;

import futbol.tacticas.Comando;
import futbol.tacticas.ComandoIrA;
import futbol.tacticas.ComandoPase;
import futbol.tacticas.ComandoTiroAPuerta;
import futbol.tacticas.SituacionJugadores;
import futbol.tacticas.concursantes.Tactica;

import java.awt.Color;
import java.awt.Point;
import java.security.SecureRandom;
import java.util.Vector;

/**
 *
 * @author Andres Maya
 */
public class TacticaMayanBeserk implements Tactica {

    private int nValores[][]={
        //{x,y,fuerza}  ->  fuerza>=0&&fuerza<=10
        //Fuerza=1/Velocidad  ->  mientras mas fuerza tenga el jugador, menor
        //      será la velocidad del mismo.
        {-145,0,4},  // Portero 1[0]
        {-119,0,4},  // Defensa 1[1]
        {-95,-48,4},  // Defensa 2[2]
        {-95,0,4},  // Defensa 3[3]
        {-95,48,4},  // Defensa 4[4]
        {-60,-35,5},  // Medio Derecho[5]
        {-60,35,5},  // Medio Izquierdo[6]
        {-40,-71,5},  // Medio Contension[7]
        {-40,71,5},  // Medio Enganche[8]
        {-30,-30,7},  // Delantero 1[9]
        {-30,30,7}  // Delantero 2[10]
    };

    private int area_defensa=1;
    private int area_media=2;
    private int area_delantera=3;
    private int area_portero=4;
    
    private int limite_defensa=-62;
    private int limite_media=58;
    
    private int limite_x_i=-160;
    private int limite_x_d=160;
    private int limite_y_ar=-120;
    private int limite_y_ab=120;
    
    private int limite_portero_y_i=-30;
    private int limite_portero_y_d=30;
    private int limite_portero_x=nValores[0][0];
    private int limite_portero_y=nValores[0][1];
    
    private Point bola_anterior=null;
    
    private Point pos_portero=new Point();//0
    private Point pos_defensa_1=new Point();//1
    private Point pos_defensa_2=new Point();//2
    private Point pos_defensa_3=new Point();//3
    private Point pos_defensa_4=new Point();//4
    private Point pos_medio_1=new Point();//5
    private Point pos_medio_2=new Point();//6
    private Point pos_medio_3=new Point();//7
    private Point pos_medio_4=new Point();//8
    private Point pos_delantero_1=new Point();//9
    private Point pos_delantero_2=new Point();//10
    
    private Point pos_sig_bola_defensa=new Point();
    private Point pos_sig_bola_media=new Point();
    private Point pos_sig_bola=new Point();
    
    private int turno=0;
    
    public String getNombre(){
        return "Furia_Maya";
    }
    public Color getColor1(){//Camiseta
        return Color.blue;
    }
    public Color getColor2(){//Pantalón
        return Color.red;
    }
    public Color getColorNumero(){//Número de la camiseta
        return Color.white;
    }
    public int getFuerza(int n){
        return nValores[n][2];
    }
    public int getXInicial(int n){
        return nValores[n][0];
    }
    public int getYInicial(int n){
        return nValores[n][1];
    }
    public Vector<Comando> getComandos(SituacionJugadores sj){
        Vector<Comando> comandos=new Vector();
        if(turno<Integer.MAX_VALUE){
            turno++;
        }else{
            turno=2;
        }
        if(turno<0){
            turno=2;
        }

        //->Posicionamiento de los jugadores.
        /*nValores[9][2]=7;
        nValores[10][2]=4;*/
        int x=0;
        int y=0;
        boolean regresarInicio=true;
        for (int n=0;n<11;n++){
            if(turno>1){
                if(n==9&&pos_delantero_1!=null&&pos_delantero_1.getX()>nValores[n][0]){
                    regresarInicio=false;
                }else if(n==10&&pos_delantero_2!=null&&pos_delantero_2.getX()>nValores[n][0]){
                    regresarInicio=false;
                }/*else if(n==7&&pos_medio_3!=null&&pos_medio_3.getX()>nValores[n][0]){
                    regresarInicio=false;
                }else if(n==8&&pos_medio_4!=null&&pos_medio_4.getX()>nValores[n][0]){
                    regresarInicio=false;
                }*/
            }
            if(regresarInicio){
                x=nValores[n][0];
                y=nValores[n][1];
                comandos.add(irA(n,x,y));
            }
            regresarInicio=true;
        }
        //<-
        
        //->Valores del campo.
        int nJug = sj.getMasCercanoDeBola();
        Point bola = sj.getBola();
        if(bola_anterior==null){
            bola_anterior=bola;
        }
        double bolaX=bola.getX();
        double bolaY=bola.getY();
        pos_sig_bola_defensa=siguientePosicion_ADefensa(bola);
        pos_sig_bola_media=siguientePosicion_AMedia(bola);
        pos_sig_bola=siguientePosicionBola(bola);
        //Point[] contrarios=sj.getContrario();
        //<-
        
        //->Movimiento Portero(0).
        comandos=estrategiaPortero(bola,comandos,sj);
        //<-
        
        //->Defensas
        //->Movimiento Defensa 1(1).
        comandos=estrategiaDefensa1(bola,comandos,sj);
        //<-
        //->Movimiento Defensa 2(2).
        comandos=estrategiaDefensa2(bola,comandos,sj);
        //<-
        //->Movimiento Defensa 3(3).
        comandos=estrategiaDefensa3(bola,comandos,sj);
        //<-
        //->Movimiento Defensa 4(4).
        comandos=estrategiaDefensa4(bola,comandos,sj);
        //<-
        //<-
        
        //->Medios
        //->Movimiento Medio 1(5).
        comandos=estrategiaMedio1(bola,comandos,sj);
        //<-
        //->Movimiento Medio 2(6).
        comandos=estrategiaMedio2(bola,comandos,sj);
        //<-
        //->Movimiento Medio 3(7).
        comandos=estrategiaMedio3(bola,comandos,sj);
        //<-
        //->Movimiento Medio 4(8).
        comandos=estrategiaMedio4(bola,comandos,sj);
        //<-
        
        //->Movimiento Delantero 1(9).
        comandos=estrategiaDelantero1(bola,comandos,sj);
        //<-
        //->Movimiento Delantero 2(10).
        comandos=estrategiaDelantero2(bola,comandos,sj);
        //<-
        //<-

        //->Cercano a la pelota
        if(nJug==0&&area(bola)!=area_portero){
            nJug=mioCercanoPos_NoPortero(bola);
        }
        comandos.add(irA(nJug,bolaX,bolaY));
        //<-
        
        //->Pases
        //comandos.add(new ComandoIrA(0,nValores[0][0], nValores[0][1]));
        /*
        comandos.add(new ComandoPase(2,5));
        comandos.add(new ComandoPase(2,6));
        comandos.add(new ComandoPase(2,7));
        comandos.add(new ComandoPase(2,8));
        comandos.add(new ComandoPase(3,5));
        comandos.add(new ComandoPase(3,6));
        comandos.add(new ComandoPase(3,7));
        comandos.add(new ComandoPase(3,8));
        comandos.add(new ComandoPase(4,5));
        comandos.add(new ComandoPase(4,6));
        comandos.add(new ComandoPase(4,7));
        comandos.add(new ComandoPase(4,8));
        comandos.add(new ComandoPase(5,9));
        comandos.add(new ComandoPase(5,10));*/
        /*comandos.add(new ComandoPase(6,9));
        comandos.add(new ComandoPase(6,10));
        comandos.add(new ComandoPase(7,9));
        comandos.add(new ComandoPase(7,10));
        comandos.add(new ComandoPase(8,9));
        comandos.add(new ComandoPase(8,10));*/
        //<-

        //->Tiro a puerta
        //SecureRandom sr=new SecureRandom();
        /*if(area(pos_delantero_1)==area_delantera){
            nValores[9][2]=7;
        }*/
        //comandos.add(new ComandoGolpearBola(9,sr.nextDouble(),sr.nextDouble()));
        /*if(area(pos_delantero_2)==area_delantera){
            nValores[10][2]=7;
        }*/
        //comandos.add(new ComandoTiroAPuerta(10,-10));
        //comandos.add(new ComandoGolpearBola(10,sr.nextDouble(),sr.nextDouble()));
        //<-
        /*
        {-149,0,5},  // Portero 1[0]
        {-105,-70,6},  // Defensa 1[1]
        {-120,-25,6},  // Defensa 2[2]
        {-120,25,6},  // Defensa 3[3]
        {-105,70,6},  // Defensa 4[4]
        {-40,70,6},  // Medio Derecho[5]
        {-40,-70,7},  // Medio Izquierdo[6]
        {-62,-1,6},  // Medio Contension[7]
        {100,-30,7},  // Medio Enganche[8]
        {50,-4,7},  // Delantero 1[9]
        {100,30,7}  // Delantero 2[10]
         */

        bola_anterior=bola;
        return comandos;
    }
    
    private boolean tiroLimpio(SituacionJugadores sj,Point inicio,Point termino)
    {
        boolean limpio=true;
        Point desplazamiento=this.desplazamiento(inicio,termino);
        Point[] contrarios=sj.getContrario();
        Point contrario=null;
        double iX=inicio.getX();
        double iY=inicio.getY();
        double tX=termino.getX();
        double tY=termino.getY();
        double dX=desplazamiento.getX();
        double dY=desplazamiento.getY();
        double incr=1;
        if(dX<0){
            incr=-1;
        }
        double porcX=this.reglaTres(tX,iX);
        double porcY=this.reglaTres(tY,iY);
        iX+=incr;
        int c=0;
        while(limpio&&iX<=tX){
            iY+=(porcX*tY);
            desplazamiento.setLocation(iX,iY);
            for(c=0;limpio&&c<contrarios.length;c++){
                contrario=contrarios[c];
                if(desplazamiento.getX()==contrario.getX()&&desplazamiento.
                getY()==contrario.getY()){
                    limpio=false;
                }
            }
            iX+=incr;
        }
        return limpio;
    }
    private double menorDistanciaEnemigo(Point posicion,SituacionJugadores sj){
        double distancia=600;
        double distanciaT=0;
        Point[] contrarios=sj.getContrario();
        Point contrario=null;
        for(int c=0;c<contrarios.length;c++){
            contrario=contrarios[c];
            distanciaT=distancia(posicion,contrario);
            if(distanciaT<distancia){
                distancia=distanciaT;
            }
        }
        return distancia;
    }
    private Point jugadorPos(int nJug){
        Point jugador=null;
        if(nJug==0){
            jugador=pos_portero;
        }else if(nJug==1){
            jugador=pos_defensa_1;
        }else if(nJug==2){
            jugador=pos_defensa_2;
        }else if(nJug==3){
            jugador=pos_defensa_3;
        }else if(nJug==4){
            jugador=pos_defensa_4;
        }else if(nJug==5){
            jugador=pos_medio_1;
        }else if(nJug==6){
            jugador=pos_medio_2;
        }else if(nJug==7){
            jugador=pos_medio_3;
        }else if(nJug==8){
            jugador=pos_medio_4;
        }else if(nJug==9){
            jugador=pos_delantero_1;
        }else if(nJug==10){
            jugador=pos_delantero_2;
        }
        return jugador;
    }
    private Point desplazamiento2(Point elementoI,Point elementoF){
        Point desplazamiento=null;
        double factor=2;
        if(elementoI!=null&&elementoF!=null){
            desplazamiento=desplazamiento(elementoI,elementoF);
            if(desplazamiento!=null){
                //->quitar
                System.out.println("desplazamiento2  C0  desplazamiento("+(
                  desplazamiento!=null?(desplazamiento.getX()+","+
                  desplazamiento.getY()):"-1,-1")+")");
                //<-
                desplazamiento.setLocation(desplazamiento.getX()*factor,
                  desplazamiento.getY()*factor);
            }
        }else{
            desplazamiento=new Point();
            SecureRandom sr=new SecureRandom();
            desplazamiento.setLocation(-10,1);
        }
        return desplazamiento;
    }
    private Vector<Comando> paseMejorado(Vector<Comando> comandos,int jO,
    int jD){
        /*Point jugadorO=jugadorPos(jO);
        Point jugador=jugadorPos(jD);
        //->quitar
        System.out.println("paseMejorado  C0  jugadorO("+(jugadorO!=null?
          (jugadorO.getX()+","+jugadorO.getY()):"-1,-1")+")->"+jO+"/jugador("+
          (jugador!=null?(jugador.getX()+","+jugador.getY()):"-1,-1")+")->"+jD);
        //<-
        Point desplazamiento=this.desplazamiento2(jugadorO,jugador);
        //ComandoGolpearBola(nJug,jug[nJug][0].x+dx,jug[nJug][0].y+dy)
        if(desplazamiento!=null){
            //->quitar
            System.out.println("paseMejorado  C1("+desplazamiento.getX()+","+
              desplazamiento.getY()+")");
            //<-
            double desX=desplazamiento.getX();
            double desY=desplazamiento.getY();
            double x=jugadorO.getX()+desX;
            double y=jugadorO.getY()+desY;
            double porc=0;
            if(x<-160){
                jugador.setLocation(-160,0);
                desplazamiento.setLocation(x,0);
                //->quitar
                System.out.println("paseMejorado  C1a  porc="+porc+"/("+x+","
                  +0+")");
                //<-
                desplazamiento=this.desplazamiento(jugador,desplazamiento);
                porc=this.reglaTres(desX,desplazamiento.getX());
                //->quitar
                System.out.println("paseMejorado  C1a  porc="+porc+"/("+desX+","
                  +desY+")/des("+desplazamiento.getX()+","+0+")");
                //<-
                if(porc<0){
                    porc*=-1;
                }
                porc=1-porc;
                desX*=porc;
                desY*=porc;
                //->quitar
                System.out.println("paseMejorado  C1a  porc="+porc+"/("+desX+","
                  +desY+")");
                //<-
            }else if(x>160){
                jugador.setLocation(160,0);
                desplazamiento.setLocation(x,0);
                //->quitar
                System.out.println("paseMejorado  C1b  porc="+porc+"/("+x+","
                  +0+")");
                //<-
                desplazamiento=this.desplazamiento(jugador,desplazamiento);
                porc=this.reglaTres(desX,desplazamiento.getX());
                //->quitar
                System.out.println("paseMejorado  C1b  porc="+porc+"/("+desX+","
                  +desY+")/des("+desplazamiento.getX()+","+0+")");
                //<-
                if(porc<0){
                    porc*=-1;
                }
                porc=1-porc;
                desX*=porc;
                desY*=porc;
                //->quitar
                System.out.println("paseMejorado  C1b  porc="+porc+"/("+desX+","
                  +desY+")");
                //<-
            }
            if(y<-120){
                jugador=new Point();
                jugador.setLocation(0,-120);
                desplazamiento.setLocation(0,y);
                //->quitar
                System.out.println("paseMejorado  C1c  porc="+porc+"/("+0+","
                  +y+")");
                //<-
                desplazamiento=this.desplazamiento(jugador,desplazamiento);
                porc=this.reglaTres(desY,desplazamiento.getY());
                //->quitar
                System.out.println("paseMejorado  C1c  porc="+porc+"/("+desX+","
                  +desY+")/des("+0+","+desplazamiento.getY()+")");
                //<-
                if(porc<0){
                    porc*=-1;
                }
                porc=1-porc;
                desX*=porc;
                desY*=porc;
                //->quitar
                System.out.println("paseMejorado  C1c  porc="+porc+"/("+desX+","
                  +desY+")");
                //<-
            }else if(y>120){
                jugador=new Point();
                jugador.setLocation(0,120);
                desplazamiento.setLocation(0,y);
                //->quitar
                System.out.println("paseMejorado  C1d  porc="+porc+"/("+0+","
                  +y+")");
                //<-
                desplazamiento=this.desplazamiento(jugador,desplazamiento);
                porc=this.reglaTres(desY,desplazamiento.getY());
                //->quitar
                System.out.println("paseMejorado  C1d  porc="+porc+"/("+desX+","
                  +desY+")/des("+0+","+desplazamiento.getY()+")");
                //<-
                if(porc<0){
                    porc*=-1;
                }
                porc=1-porc;
                desX*=porc;
                desY*=porc;
                //->quitar
                System.out.println("paseMejorado  C1d  porc="+porc+"/("+desX+","
                  +desY+")");
                //<-
            }
            x=jugadorO.getX()+desX;
            y=jugadorO.getY()+desY;
            //->quitar
            System.out.println("paseMejorado  C2("+x+","+y+")");
            //<-
            comandos.add(new ComandoGolpearBola(0,x,y));
        }else{
            comandos.add(new ComandoGolpearBola(0,jugador.getX(),jugador.getY()));
            //comandos.add(new ComandoPase(jO,jD));
            //->quitar
            System.out.println("paseMejorado  C3");
            //<-
        }
        comandos.add(new ComandoTiroAPuerta(jO,0));*/
        comandos.add(new ComandoPase(jO,jD));
        return comandos;
    }
    
    /**Jugador 0.*/
    private Vector<Comando> estrategiaPortero(Point bola,
    Vector<Comando> comandos,SituacionJugadores sj){
        double bolaX=bola.getX();
        double bolaY=bola.getY();
        double y=bolaY/2;
        double x=0;
        int sigArea=0;
        if(area(bola)==area_defensa){
            x=limite_x_i+1;
        }else{
            x=nValores[0][0];
        }
        if(area(bola)==area_portero){
            x=bola.getX();
            y=bola.getY();
        }else{
            Point siguientePosBola=siguientePosicion_APortero(bola);
            if(siguientePosBola!=null&&area(siguientePosBola)==area_portero){
            /*&&mioCercanoSigPos(bola)==0*/
                x=siguientePosBola.getX();
                y=siguientePosBola.getY();
                /*System.out.println("BAn("+bola_anterior.getX()+","+
                  bola_anterior.getY()+")/BAc("+bola.getX()+","+bola.getY()+
                  ")/SP("+x+","+y+")");*/
            }
        }
        if (y<(limite_portero_y_i-1)) y=limite_portero_y_i-1;
        if (y>(limite_portero_y_d+1)) y=limite_portero_y_d+1;
        comandos.add(irA(0,x,y));
        int sigJugAd=sj.getSiguienteJugador(0);
        
        double distancia=0;
        double distanciaT=0;
        for(int jugador=1;jugador<5;jugador++){
            if(jugador==1){
                distanciaT=menorDistanciaEnemigo(pos_defensa_1,sj);
                if(distanciaT>distancia&&this.tiroLimpio(sj,pos_portero,
                pos_defensa_1)){
                    distancia=distanciaT;
                    sigJugAd=1;
                }
            }else if(jugador==2){
                distanciaT=menorDistanciaEnemigo(pos_defensa_2,sj);
                if(distanciaT>distancia&&this.tiroLimpio(sj,pos_portero,
                pos_defensa_2)){
                    distancia=distanciaT;
                    sigJugAd=2;
                }
            }else if(jugador==3){
                distanciaT=menorDistanciaEnemigo(pos_defensa_3,sj);
                if(distanciaT>distancia&&this.tiroLimpio(sj,pos_portero,
                pos_defensa_3)){
                    distancia=distanciaT;
                    sigJugAd=3;
                }
            }else if(jugador==4){
                distanciaT=menorDistanciaEnemigo(pos_defensa_4,sj);
                if(distanciaT>distancia&&this.tiroLimpio(sj,pos_portero,
                pos_defensa_4)){
                    distancia=distanciaT;
                    sigJugAd=4;
                }
            }
        }
        
        comandos=paseMejorado(comandos,0,sigJugAd);
        /*Point jugadorO=jugadorPos(0);
        Point jugador=jugadorPos(sigJugAd);
        jugadorO=this.desplazamiento2(jugadorO,jugador);
        if(jugador!=null){
            comandos.add(new ComandoGolpearBola(0,jugador.getX(),jugador.getY()));
        }else{
            comandos.add(new ComandoPase(0,sigJugAd));
        }*/
        return comandos;
    }
    /**Jugador 1.*/
    private Vector<Comando> estrategiaDefensa1(Point bola,
    Vector<Comando> comandos,SituacionJugadores sj){
        double bolaX=bola.getX();
        double bolaY=bola.getY();
        int x=nValores[1][0];
        int y=(int)((bolaY/2)*-1);
        if(pos_portero!=null&&area(pos_portero)!=area_portero){
            x=this.nValores[0][0];
            y=(int)(bolaY/2);
        }
        if (y<-20) y=-20;
        if (y>20) y=20;
        if(this.mioCercanoPos(pos_sig_bola_defensa)==1){
            x=(int)pos_sig_bola_defensa.getX();
            y=(int)pos_sig_bola_defensa.getY();
        }
        if(this.mioCercanoPos(pos_sig_bola)==1){
            x=(int)pos_sig_bola.getX();
            y=(int)pos_sig_bola.getY();
        }
        comandos.add(irA(1,x,y));
        int sigJugAd=sj.getSiguienteJugador(1);
        
        double distancia=0;
        double distanciaT=0;
        for(int jugador=2;jugador<5;jugador++){
            if(jugador==2){
                distanciaT=menorDistanciaEnemigo(pos_defensa_2,sj);
                if(distanciaT>distancia&&pos_defensa_1.getX()<pos_defensa_2.
                getX()&&this.tiroLimpio(sj,pos_defensa_1,pos_defensa_2)){
                    distancia=distanciaT;
                    sigJugAd=2;
                }
            }else if(jugador==3){
                distanciaT=menorDistanciaEnemigo(pos_defensa_3,sj);
                if(distanciaT>distancia&&pos_defensa_1.getX()<pos_defensa_3.
                getX()&&this.tiroLimpio(sj,pos_defensa_1,pos_defensa_3)){
                    distancia=distanciaT;
                    sigJugAd=3;
                }
            }else if(jugador==4){
                distanciaT=menorDistanciaEnemigo(pos_defensa_4,sj);
                if(distanciaT>distancia&&pos_defensa_1.getX()<pos_defensa_4.
                getX()&&this.tiroLimpio(sj,pos_defensa_1,pos_defensa_4)){
                    distancia=distanciaT;
                    sigJugAd=4;
                }
            }
        }
        
        comandos=paseMejorado(comandos,1,sigJugAd);
        /*Point jugador=jugadorPos(sigJugAd);
        if(jugador!=null){
            comandos.add(new ComandoGolpearBola(1,jugador.getX(),jugador.getY()));
        }else{
            comandos.add(new ComandoPase(1,sigJugAd));
        }*/
        return comandos;
    }
    /**Jugador 2.*/
    private Vector<Comando> estrategiaDefensa2(Point bola,
    Vector<Comando> comandos,SituacionJugadores sj){
        int nContrario=sj.getContrarioMasCerca(2);
        Point[] contrarios=sj.getContrario();
        Point contrario=contrarios[nContrario];
        double x=pos_defensa_2.getX();
        double y=pos_defensa_2.getY();
        if(this.mioCercanoPos(contrario)==2||this.mioCercanoPos(contrario)!=4){
            x=contrario.getX()-10;
            y=contrario.getY();
        }
        if(this.mioCercanoPos(pos_sig_bola_defensa)==2){
            x=(int)pos_sig_bola_defensa.getX();
            y=(int)pos_sig_bola_defensa.getY();
        }
        if(this.mioCercanoPos(pos_sig_bola)==2){
            x=(int)pos_sig_bola.getX();
            y=(int)pos_sig_bola.getY();
        }
        comandos.add(irA(2,x,y));
        //comandos.add(irA(2,bola.getX(),bola.getY()));
        /*comandos.add(new ComandoPase(2,5));
        comandos.add(new ComandoPase(2,6));
        comandos.add(new ComandoPase(2,7));
        comandos.add(new ComandoPase(2,8));*/
        int sigJugAd=sj.getSiguienteJugador(2);
        
        double distancia=0;
        double distanciaT=0;
        for(int jugador=5;jugador<9;jugador++){
            if(jugador==5){
                distanciaT=menorDistanciaEnemigo(pos_medio_1,sj);
                if(distanciaT>distancia&&pos_defensa_2.getX()<pos_medio_1.getX()
                &&this.tiroLimpio(sj,pos_defensa_2,pos_medio_1)){
                    distancia=distanciaT;
                    sigJugAd=5;
                }
            }else if(jugador==6){
                distanciaT=menorDistanciaEnemigo(pos_medio_2,sj);
                if(distanciaT>distancia&&pos_defensa_2.getX()<pos_medio_2.getX()
                &&this.tiroLimpio(sj,pos_defensa_2,pos_medio_2)){
                    distancia=distanciaT;
                    sigJugAd=6;
                }
            }else if(jugador==7){
                distanciaT=menorDistanciaEnemigo(pos_medio_3,sj);
                if(distanciaT>distancia&&pos_defensa_2.getX()<pos_medio_3.getX()
                &&this.tiroLimpio(sj,pos_defensa_2,pos_medio_3)){
                    distancia=distanciaT;
                    sigJugAd=7;
                }
            }else if(jugador==8){
                distanciaT=menorDistanciaEnemigo(pos_medio_4,sj);
                if(distanciaT>distancia&&pos_defensa_2.getX()<pos_medio_4.getX()
                &&this.tiroLimpio(sj,pos_defensa_2,pos_medio_4)){
                    distancia=distanciaT;
                    sigJugAd=8;
                }
            }
        }
        
        comandos=paseMejorado(comandos,2,sigJugAd);
        /*Point jugador=jugadorPos(sigJugAd);
        if(jugador!=null){
            comandos.add(new ComandoGolpearBola(2,jugador.getX(),jugador.getY()));
        }else{
            comandos.add(new ComandoPase(2,sigJugAd));
        }*/
        return comandos;
    }
    /**Jugador 3.*/
    private Vector<Comando> estrategiaDefensa3(Point bola,
    Vector<Comando> comandos,SituacionJugadores sj){
        int nContrario=sj.getContrarioMasCerca(3);
        Point[] contrarios=sj.getContrario();
        Point contrario=contrarios[nContrario];
        double x=pos_defensa_3.getX();//contrario.getX()+10;
        double y=pos_defensa_3.getY();//contrario.getY();
        if(this.mioCercanoPos(pos_sig_bola_defensa)==3){
            x=pos_sig_bola_defensa.getX();
            y=pos_sig_bola_defensa.getY();
        }
        if(this.mioCercanoPos(pos_sig_bola)==3){
            x=(int)pos_sig_bola.getX();
            y=(int)pos_sig_bola.getY();
        }
        if(x!=pos_defensa_3.getX()||y!=pos_defensa_3.getY()){
            comandos.add(irA(3,x,y));
        }
        //comandos.add(irA(3,bola.getX(),bola.getY()));
        /*comandos.add(new ComandoPase(3,5));
        comandos.add(new ComandoPase(3,6));
        comandos.add(new ComandoPase(3,7));
        comandos.add(new ComandoPase(3,8));*/
        int sigJugAd=sj.getSiguienteJugador(3);
        
        double distancia=0;
        double distanciaT=0;
        for(int jugador=5;jugador<9;jugador++){
            if(jugador==5){
                distanciaT=menorDistanciaEnemigo(pos_medio_1,sj);
                if(distanciaT>distancia&&pos_defensa_3.getX()<pos_medio_1.getX()
                &&this.tiroLimpio(sj,pos_defensa_3,pos_medio_1)){
                    distancia=distanciaT;
                    sigJugAd=5;
                }
            }else if(jugador==6){
                distanciaT=menorDistanciaEnemigo(pos_medio_2,sj);
                if(distanciaT>distancia&&pos_defensa_3.getX()<pos_medio_2.getX()
                &&this.tiroLimpio(sj,pos_defensa_3,pos_medio_2)){
                    distancia=distanciaT;
                    sigJugAd=6;
                }
            }else if(jugador==7){
                distanciaT=menorDistanciaEnemigo(pos_medio_3,sj);
                if(distanciaT>distancia&&pos_defensa_3.getX()<pos_medio_3.getX()
                &&this.tiroLimpio(sj,pos_defensa_3,pos_medio_3)){
                    distancia=distanciaT;
                    sigJugAd=7;
                }
            }else if(jugador==8){
                distanciaT=menorDistanciaEnemigo(pos_medio_4,sj);
                if(distanciaT>distancia&&pos_defensa_3.getX()<pos_medio_4.getX()
                &&this.tiroLimpio(sj,pos_defensa_3,pos_medio_4)){
                    distancia=distanciaT;
                    sigJugAd=8;
                }
            }
        }
        
        comandos=paseMejorado(comandos,3,sigJugAd);
        /*Point jugador=jugadorPos(sigJugAd);
        if(jugador!=null){
            comandos.add(new ComandoGolpearBola(3,jugador.getX(),jugador.getY()));
        }else{
            comandos.add(new ComandoPase(3,sigJugAd));
        }*/
        return comandos;
    }
    /**Jugador 4.*/
    private Vector<Comando> estrategiaDefensa4(Point bola,
    Vector<Comando> comandos,SituacionJugadores sj){
        int nContrario=sj.getContrarioMasCerca(4);
        Point[] contrarios=sj.getContrario();
        Point contrario=contrarios[nContrario];
        double x=pos_defensa_4.getX();
        double y=pos_defensa_4.getY();
        if(this.mioCercanoPos(contrario)==4||this.mioCercanoPos(contrario)!=2){
            x=contrario.getX()-10;
            y=contrario.getY();
        }
        if(this.mioCercanoPos(pos_sig_bola_defensa)==4){
            x=pos_sig_bola_defensa.getX();
            y=pos_sig_bola_defensa.getY();
        }
        if(this.mioCercanoPos(pos_sig_bola)==4){
            x=(int)pos_sig_bola.getX();
            y=(int)pos_sig_bola.getY();
        }
        comandos.add(irA(4,x,y));
        //comandos.add(irA(4,bola.getX(),bola.getY()));
        /*comandos.add(new ComandoPase(4,5));
        comandos.add(new ComandoPase(4,6));
        comandos.add(new ComandoPase(4,7));
        comandos.add(new ComandoPase(4,8));*/
        int sigJugAd=sj.getSiguienteJugador(4);
        
        double distancia=0;
        double distanciaT=0;
        for(int jugador=5;jugador<9;jugador++){
            if(jugador==5){
                distanciaT=menorDistanciaEnemigo(pos_medio_1,sj);
                if(distanciaT>distancia&&pos_defensa_4.getX()<pos_medio_1.getX()
                &&this.tiroLimpio(sj,pos_defensa_4,pos_medio_1)){
                    distancia=distanciaT;
                    sigJugAd=5;
                }
            }else if(jugador==6){
                distanciaT=menorDistanciaEnemigo(pos_medio_2,sj);
                if(distanciaT>distancia&&pos_defensa_4.getX()<pos_medio_2.getX()
                &&this.tiroLimpio(sj,pos_defensa_4,pos_medio_2)){
                    distancia=distanciaT;
                    sigJugAd=6;
                }
            }else if(jugador==7){
                distanciaT=menorDistanciaEnemigo(pos_medio_3,sj);
                if(distanciaT>distancia&&pos_defensa_4.getX()<pos_medio_3.getX()
                &&this.tiroLimpio(sj,pos_defensa_4,pos_medio_3)){
                    distancia=distanciaT;
                    sigJugAd=7;
                }
            }else if(jugador==8){
                distanciaT=menorDistanciaEnemigo(pos_medio_4,sj);
                if(distanciaT>distancia&&pos_defensa_4.getX()<pos_medio_4.getX()
                &&this.tiroLimpio(sj,pos_defensa_4,pos_medio_4)){
                    distancia=distanciaT;
                    sigJugAd=8;
                }
            }
        }
        
        comandos=paseMejorado(comandos,4,sigJugAd);
        /*Point jugador=jugadorPos(sigJugAd);
        if(jugador!=null){
            comandos.add(new ComandoGolpearBola(4,jugador.getX(),jugador.getY()));
        }else{
            comandos.add(new ComandoPase(4,sigJugAd));
        }*/
        return comandos;
    }
    /**Jugador 5.*/
    private Vector<Comando> estrategiaMedio1(Point bola,
    Vector<Comando> comandos,SituacionJugadores sj){
        int nContrario=sj.getContrarioMasCerca(5);
        Point[] contrarios=sj.getContrario();
        Point contrario=contrarios[nContrario];
        SecureRandom sr=new SecureRandom();
        long avanceX=sr.nextLong()%5;
        double x=pos_medio_1.getX();//contrario.getX()-10;
        double y=pos_medio_1.getY();//contrario.getY();
        if(this.mioCercanoPos(pos_sig_bola_media)==5){
            x=pos_sig_bola_media.getX();
            y=pos_sig_bola_media.getY();
        }
        if(this.mioCercanoPos(pos_sig_bola)==5){
            x=(int)pos_sig_bola.getX();
            y=(int)pos_sig_bola.getY();
        }
        if(x!=pos_medio_1.getX()||y!=pos_medio_1.getY()){
            comandos.add(irA(5,x,y));
        }
        //comandos.add(irA(4,bola.getX(),bola.getY()));
        //comandos.add(new ComandoPase(5,9));
        //comandos.add(new ComandoPase(5,10));
        int sigJugAd=sj.getSiguienteJugador(5);
        
        double distancia=0;
        double distanciaT=0;
        for(int jugador=9;jugador<11;jugador++){
            if(jugador==9){
                distanciaT=menorDistanciaEnemigo(pos_delantero_1,sj);
                if(distanciaT>distancia&&pos_medio_1.getX()<pos_delantero_1.
                getX()&&this.tiroLimpio(sj,pos_medio_1,pos_delantero_1)){
                    distancia=distanciaT;
                    sigJugAd=9;
                }
            }else if(jugador==10){
                distanciaT=menorDistanciaEnemigo(pos_delantero_2,sj);
                if(distanciaT>distancia&&pos_medio_1.getX()<pos_delantero_2.
                getX()&&this.tiroLimpio(sj,pos_medio_1,pos_delantero_2)){
                    distancia=distanciaT;
                    sigJugAd=10;
                }
            }
        }
        
        comandos=paseMejorado(comandos,5,sigJugAd);
        /*Point jugador=jugadorPos(sigJugAd);
        if(jugador!=null){
            comandos.add(new ComandoGolpearBola(5,jugador.getX(),jugador.getY()));
        }else{
            comandos.add(new ComandoPase(5,sigJugAd));
        }*/
        return comandos;
    }
    /**Jugador 6.*/
    private Vector<Comando> estrategiaMedio2(Point bola,
    Vector<Comando> comandos,SituacionJugadores sj){
        int nContrario=sj.getContrarioMasCerca(6);
        Point[] contrarios=sj.getContrario();
        Point contrario=contrarios[nContrario];
        SecureRandom sr=new SecureRandom();
        long avanceX=sr.nextLong()%5;
        double x=pos_medio_2.getX();//contrario.getX()-10;
        double y=pos_medio_2.getY();//contrario.getY();
        if(this.mioCercanoPos(pos_sig_bola_media)==6){
            x=pos_sig_bola_media.getX();
            y=pos_sig_bola_media.getY();
        }
        if(this.mioCercanoPos(pos_sig_bola)==6){
            x=(int)pos_sig_bola.getX();
            y=(int)pos_sig_bola.getY();
        }
        if(x!=pos_medio_2.getX()||y!=pos_medio_2.getY()){
            comandos.add(irA(6,x,y));
        }
        //comandos.add(irA(4,bola.getX(),bola.getY()));
        //comandos.add(new ComandoPase(6,9));
        //comandos.add(new ComandoPase(6,10));
        int sigJugAd=sj.getSiguienteJugador(6);
        
        double distancia=0;
        double distanciaT=0;
        for(int jugador=9;jugador<11;jugador++){
            if(jugador==9){
                distanciaT=menorDistanciaEnemigo(pos_delantero_1,sj);
                if(distanciaT>distancia&&pos_medio_2.getX()<pos_delantero_1.
                getX()&&this.tiroLimpio(sj,pos_medio_2,pos_delantero_1)){
                    distancia=distanciaT;
                    sigJugAd=9;
                }
            }else if(jugador==10){
                distanciaT=menorDistanciaEnemigo(pos_delantero_2,sj);
                if(distanciaT>distancia&&pos_medio_2.getX()<pos_delantero_2.
                getX()&&this.tiroLimpio(sj,pos_medio_2,pos_delantero_2)){
                    distancia=distanciaT;
                    sigJugAd=10;
                }
            }
        }
        
        comandos=paseMejorado(comandos,6,sigJugAd);
        /*Point jugador=jugadorPos(sigJugAd);
        if(jugador!=null){
            comandos.add(new ComandoGolpearBola(6,jugador.getX(),jugador.getY()));
        }else{
            comandos.add(new ComandoPase(6,sigJugAd));
        }*/
        return comandos;
    }
    /**Jugador 7.*/
    private Vector<Comando> estrategiaMedio3(Point bola,
    Vector<Comando> comandos,SituacionJugadores sj){
        int nContrario=sj.getContrarioMasCerca(7);
        Point[] contrarios=sj.getContrario();
        Point contrario=contrarios[nContrario];
        SecureRandom sr=new SecureRandom();
        long avanceX=sr.nextLong()%5;
        double x=pos_medio_3.getX();//contrario.getX()-10;
        double y=pos_medio_3.getY();//contrario.getY();
        if(this.mioCercanoPos(pos_sig_bola_media)==7){
            x=pos_sig_bola_media.getX();
            y=pos_sig_bola_media.getY();
        }
        if(this.mioCercanoPos(pos_sig_bola)==7){
            x=(int)pos_sig_bola.getX();
            y=(int)pos_sig_bola.getY();
        }
        if(x!=pos_medio_3.getX()||y!=pos_medio_3.getY()){
            comandos.add(irA(7,x,y));
        }
        //comandos.add(irA(4,bola.getX(),bola.getY()));
        //comandos.add(new ComandoPase(7,9));
        //comandos.add(new ComandoPase(7,10));
        int sigJugAd=sj.getSiguienteJugador(7);
        
        double distancia=0;
        double distanciaT=0;
        for(int jugador=9;jugador<11;jugador++){
            if(jugador==9){
                distanciaT=menorDistanciaEnemigo(pos_delantero_1,sj);
                if(distanciaT>distancia&&pos_medio_3.getX()<pos_delantero_1.
                getX()&&this.tiroLimpio(sj,pos_medio_3,pos_delantero_1)){
                    distancia=distanciaT;
                    sigJugAd=9;
                }
            }else if(jugador==10){
                distanciaT=menorDistanciaEnemigo(pos_delantero_2,sj);
                if(distanciaT>distancia&&pos_medio_3.getX()<pos_delantero_2.
                getX()&&this.tiroLimpio(sj,pos_medio_3,pos_delantero_2)){
                    distancia=distanciaT;
                    sigJugAd=10;
                }
            }
        }
        
        comandos=paseMejorado(comandos,7,sigJugAd);
        /*Point jugador=jugadorPos(sigJugAd);
        if(jugador!=null){
            comandos.add(new ComandoGolpearBola(7,jugador.getX(),jugador.getY()));
        }else{
            comandos.add(new ComandoPase(7,sigJugAd));
        }*/
        return comandos;
    }
    /**Jugador 8.*/
    private Vector<Comando> estrategiaMedio4(Point bola,
    Vector<Comando> comandos,SituacionJugadores sj){
        int nContrario=sj.getContrarioMasCerca(8);
        Point[] contrarios=sj.getContrario();
        Point contrario=contrarios[nContrario];
        SecureRandom sr=new SecureRandom();
        long avanceX=sr.nextLong()%5;
        double x=pos_medio_4.getX();//contrario.getX()-10;
        double y=pos_medio_4.getY();//contrario.getY();
        if(this.mioCercanoPos(pos_sig_bola_media)==8){
            x=pos_sig_bola_media.getX();
            y=pos_sig_bola_media.getY();
        }
        if(this.mioCercanoPos(pos_sig_bola)==8){
            x=(int)pos_sig_bola.getX();
            y=(int)pos_sig_bola.getY();
        }
        if(x!=pos_medio_4.getX()||y!=pos_medio_4.getY()){
            comandos.add(irA(8,x,y));
        }
        //comandos.add(irA(4,bola.getX(),bola.getY()));
        //comandos.add(new ComandoPase(8,9));
        //comandos.add(new ComandoPase(8,10));
        int sigJugAd=sj.getSiguienteJugador(8);
        
        double distancia=0;
        double distanciaT=0;
        for(int jugador=9;jugador<11;jugador++){
            if(jugador==9){
                distanciaT=menorDistanciaEnemigo(pos_delantero_1,sj);
                if(distanciaT>distancia&&pos_medio_4.getX()<pos_delantero_1.
                getX()&&this.tiroLimpio(sj,pos_medio_4,pos_delantero_1)){
                    distancia=distanciaT;
                    sigJugAd=9;
                }
            }else if(jugador==10){
                distanciaT=menorDistanciaEnemigo(pos_delantero_2,sj);
                if(distanciaT>distancia&&
                pos_medio_4.getX()<pos_delantero_2.getX()){
                    distancia=distanciaT;
                    sigJugAd=10;
                }
            }
        }
        
        comandos=paseMejorado(comandos,8,sigJugAd);
        /*Point jugador=jugadorPos(sigJugAd);
        if(jugador!=null){
            comandos.add(new ComandoGolpearBola(8,jugador.getX(),jugador.getY()));
        }else{
            comandos.add(new ComandoPase(8,sigJugAd));
        }*/
        return comandos;
    }
    /**Jugador 9.*/
    private Vector<Comando> estrategiaDelantero1(Point bola,
    Vector<Comando> comandos,SituacionJugadores sj){
        int nContrario=sj.getContrarioMasCerca(8);
        Point[] contrarios=sj.getContrario();
        Point contrario=contrarios[nContrario];
        SecureRandom sr=new SecureRandom();
        long avanceX=sr.nextLong()%5;
        double x=pos_delantero_1.getX();//contrario.getX()-10;
        double y=pos_delantero_1.getY();//contrario.getY();
        /*if(this.mioCercanoPos(pos_sig_bola_media)==8){
            x=pos_sig_bola_media.getX();
            y=pos_sig_bola_media.getY();
        }*/
        if(this.mioCercanoPos(pos_sig_bola)==9){
            x=(int)pos_sig_bola.getX();
            y=(int)pos_sig_bola.getY();
        }
        
        if(x!=pos_delantero_1.getX()||y!=pos_delantero_1.getY()){
            comandos.add(irA(8,x,y));
        }
        //comandos.add(irA(4,bola.getX(),bola.getY()));
        //comandos.add(new ComandoPase(8,9));
        //comandos.add(new ComandoPase(8,10));
        /*int sigJugAd=sj.getSiguienteJugador(4);
        comandos.add(new ComandoPase(4,sigJugAd));*/
        int desviacion=10;
        if(pos_delantero_1.getX()>0){
            desviacion=-10;
        }
        comandos.add(new ComandoTiroAPuerta(9,desviacion));
        return comandos;
    }
    /**Jugador 10.*/
    private Vector<Comando> estrategiaDelantero2(Point bola,
    Vector<Comando> comandos,SituacionJugadores sj){
        int nContrario=sj.getContrarioMasCerca(8);
        Point[] contrarios=sj.getContrario();
        Point contrario=contrarios[nContrario];
        SecureRandom sr=new SecureRandom();
        long avanceX=sr.nextLong()%5;
        double x=pos_delantero_1.getX();//contrario.getX()-10;
        double y=pos_delantero_1.getY();//contrario.getY();
        /*if(this.mioCercanoPos(pos_sig_bola_media)==8){
            x=pos_sig_bola_media.getX();
            y=pos_sig_bola_media.getY();
        }*/
        if(this.mioCercanoPos(pos_sig_bola)==9){
            x=(int)pos_sig_bola.getX();
            y=(int)pos_sig_bola.getY();
        }
        
        if(x!=pos_delantero_1.getX()||y!=pos_delantero_1.getY()){
            comandos.add(irA(8,x,y));
        }
        //comandos.add(irA(4,bola.getX(),bola.getY()));
        //comandos.add(new ComandoPase(8,9));
        //comandos.add(new ComandoPase(8,10));
        /*int sigJugAd=sj.getSiguienteJugador(4);
        comandos.add(new ComandoPase(4,sigJugAd));*/
        int desviacion=-10;
        if(pos_delantero_1.getX()>0){
            desviacion=10;
        }
        comandos.add(new ComandoTiroAPuerta(10,desviacion));
        return comandos;
    }
    
    private ComandoIrA irA(int jugador,double x,double y){
        guardarPosicion(jugador,x,y);
        return new ComandoIrA(jugador,x,y);
    }
    private void guardarPosicion(int jugador,double x,double y){
        if(jugador==0){
            pos_portero.setLocation(x,y);
        }else if(jugador==1){
            pos_defensa_1.setLocation(x,y);
        }else if(jugador==2){
            pos_defensa_2.setLocation(x,y);
        }else if(jugador==3){
            pos_defensa_3.setLocation(x,y);
        }else if(jugador==4){
            pos_defensa_4.setLocation(x,y);
        }else if(jugador==5){
            pos_medio_1.setLocation(x,y);
        }else if(jugador==6){
            pos_medio_2.setLocation(x,y);
        }else if(jugador==7){
            pos_medio_3.setLocation(x,y);
        }else if(jugador==8){
            pos_medio_4.setLocation(x,y);
        }else if(jugador==9){
            pos_delantero_1.setLocation(x,y);
        }else if(jugador==10){
            pos_delantero_2.setLocation(x,y);
        }
    }
    private int area(Point elemento){
        int area=area_delantera;
        double x=elemento.getX();
        double y=elemento.getY();
        if(x>=limite_x_i&&x<=limite_portero_x&&y>=(limite_portero_y_i-1)&&y<=
        (limite_portero_y_d+1)){
            area=this.area_portero;
        }else if(x>=limite_x_i&&x<=limite_defensa){
            area=area_defensa;
        }else if(x<=limite_media){
            area=area_media;
        }
        return area;
    }
    private boolean bolaEnMovimiento(Point bola){
        boolean movimiento=false;
        if(bola_anterior==null||(bola_anterior.getX()!=bola.getX()||
        bola_anterior.getY()!=bola.getY())){
            movimiento=true;
        }
        return movimiento;
    }
    private Point desplazamiento(Point elementoI,Point elementoF){
        Point desplazamiento=new Point();
        double antX=elementoI.getX();
        double antY=elementoI.getY();
        double actX=elementoF.getX();
        double actY=elementoF.getY();
        double difX=0;
        double difY=0;
        if((actX<0&&antX>0)||(actX>0&&antX<0)){
            difX=(actX-0)+(0-antX);
        }else{
            difX=actX-antX;
        }
        if((actY<0&&antY>0)||(actY>0&&antY<0)){
            difY=(actY-0)+(0-antY);
        }else{
            difY=actY-antY;
        }
        desplazamiento.setLocation(difX,difY);
        return desplazamiento;
    }
    private boolean tiroAPorteria(Point bola){
        boolean valido=false;
        Point desplazamiento=null;
        if(bolaEnMovimiento(bola)){
            desplazamiento=desplazamiento(bola_anterior,bola);
            if(desplazamiento.getX()<0){
                valido=true;
            }
        }
        return valido;
    }
    private double reglaTres(double total,double nuevo){
        return (nuevo/total);
    }
    private Point siguientePosicion_AMedia(Point bola){
        Point siguiente=null;
        double sigX=0;
        double xT=0;
        double xN=0;
        double yT=0;
        double yN=0;
        double porc=0;
        if(tiroAPorteria(bola)){
            siguiente=desplazamiento(bola_anterior,bola);
            sigX=this.limite_media;
            xT=siguiente.getX();
            xN=sigX-bola_anterior.getX();
            porc=reglaTres(xT,xN);
            if(porc<0){
                porc*=-1;
            }
            yT=siguiente.getY();
            yN=bola_anterior.getY()+(yT*porc);
            siguiente=new Point();
            siguiente.setLocation(sigX,yN);
            if(area(siguiente)!=area_defensa){
                siguiente=null;
            }
        }
        if(siguiente==null){
            siguiente=bola;
        }
        return siguiente;
    }
    private Point siguientePosicion_ADefensa(Point bola){
        Point siguiente=null;
        double sigX=0;
        double xT=0;
        double xN=0;
        double yT=0;
        double yN=0;
        double porc=0;
        if(tiroAPorteria(bola)){
            siguiente=desplazamiento(bola_anterior,bola);
            sigX=limite_defensa;
            xT=siguiente.getX();
            xN=sigX-bola_anterior.getX();
            porc=reglaTres(xT,xN);
            if(porc<0){
                porc*=-1;
            }
            yT=siguiente.getY();
            yN=bola_anterior.getY()+(yT*porc);
            siguiente=new Point();
            siguiente.setLocation(sigX,yN);
            if(area(siguiente)!=area_defensa){
                siguiente=null;
            }
        }
        if(siguiente==null){
            siguiente=bola;
        }
        return siguiente;
    }
    private Point siguientePosicion_APortero(Point bola){
        Point siguiente=null;
        double sigX=0;
        double xT=0;
        double xN=0;
        double yT=0;
        double yN=0;
        double porc=0;
        /*int limRevs=60;
        int c=0;*/
        if(/*area(bola)==area_defensa&&*/tiroAPorteria(bola)){
            siguiente=desplazamiento(bola_anterior,bola);
            sigX=limite_portero_x;
            xT=siguiente.getX();
            xN=sigX-bola_anterior.getX();
            porc=reglaTres(xT,xN);
            if(porc<0){
                porc*=-1;
            }
            yT=siguiente.getY();
            yN=bola_anterior.getY()+(yT*porc);
            siguiente=new Point();
            siguiente.setLocation(sigX,yN);
            /*System.out.println("BAN("+bola_anterior.getX()+","+bola_anterior.
              getY()+")/BAC=("+bola.getX()+","+bola.getY()+")/xT="+xT+"/xN="+xN+
              "/yT="+yT+"/yN="+yN+"/porc="+porc);*/
            if(area(siguiente)!=area_portero){
                siguiente=null;
            }
            /*siguiente=siguientePosicionBola(bola);
            c++;
            while(c<limRevs&&area(siguiente)!=area_portero){
                siguiente=siguientePosicionBola(bola);
                c++;
            }*/
        }
        if(siguiente==null){
            siguiente=bola;
        }
        return siguiente;
    }
    private Point siguientePosicionBola(Point bola,int pasos){
        Point siguiente=new Point();
        Point anterior=bola_anterior;
        double x=0;
        double y=0;
        if(!bolaEnMovimiento(bola)){
            siguiente=bola;
        }else{
            if(pasos<1){
                pasos=1;
            }
            for(int c=0;c<pasos;c++){
                siguiente=desplazamiento(anterior,bola);
                x=bola.getX()+siguiente.getX();
                y=bola.getY()+siguiente.getY();
                if(x<limite_x_i){
                    x=limite_x_i+(limite_x_i-x);
                }else if(x>limite_x_d){
                    x=limite_x_d+(limite_x_d-x);
                }
                if(y<limite_y_ar){
                    y=limite_y_ar+(limite_y_ar-y);
                }else if(y>limite_y_ab){
                    y=limite_y_ab+(limite_y_ab-y);
                }
                siguiente.setLocation(x,y);
                anterior=new Point();
                anterior.setLocation(siguiente.getX(),siguiente.getY());
            }
        }
        return siguiente;
    }
    private Point siguientePosicionBola(Point bola){
        return siguientePosicionBola(bola,1);
    }
    private double distancia(Point posicion1,Point posicion2){
        double x=posicion1.getX()-posicion2.getX();
        double y=posicion1.getY()-posicion2.getY();
        double distancia=Math.sqrt((x*x)+(y*y));
        return distancia;
    }
    private int mioCercanoPos_NoPortero(Point punto){
        int jugador=0;
        double distancia=320;
        double distanciaA=0;
        distanciaA=distancia(pos_defensa_1,punto);
        if(distanciaA<distancia){
            jugador=1;
            distancia=distanciaA;
        }
        distanciaA=distancia(pos_defensa_2,punto);
        if(distanciaA<distancia){
            jugador=2;
            distancia=distanciaA;
        }
        distanciaA=distancia(pos_defensa_3,punto);
        if(distanciaA<distancia){
            jugador=3;
            distancia=distanciaA;
        }
        distanciaA=distancia(pos_defensa_4,punto);
        if(distanciaA<distancia){
            jugador=4;
            distancia=distanciaA;
        }
        distanciaA=distancia(pos_medio_1,punto);
        if(distanciaA<distancia){
            jugador=5;
            distancia=distanciaA;
        }
        distanciaA=distancia(pos_medio_2,punto);
        if(distanciaA<distancia){
            jugador=6;
            distancia=distanciaA;
        }
        distanciaA=distancia(pos_medio_3,punto);
        if(distanciaA<distancia){
            jugador=7;
            distancia=distanciaA;
        }
        distanciaA=distancia(pos_medio_4,punto);
        if(distanciaA<distancia){
            jugador=8;
            distancia=distanciaA;
        }
        distanciaA=distancia(pos_delantero_1,punto);
        if(distanciaA<distancia){
            jugador=9;
            distancia=distanciaA;
        }
        distanciaA=distancia(pos_delantero_2,punto);
        if(distanciaA<distancia){
            jugador=10;
        }
        return jugador;
    }
    private Point obtenerPosicion(int jugador){
        Point posicion=null;
        if(jugador==0){
            posicion=pos_portero;
        }else if(jugador==1){
            posicion=pos_defensa_1;
        }else if(jugador==2){
            posicion=pos_defensa_2;
        }else if(jugador==3){
            posicion=pos_defensa_3;
        }else if(jugador==4){
            posicion=pos_defensa_4;
        }else if(jugador==5){
            posicion=pos_medio_1;
        }else if(jugador==6){
            posicion=pos_medio_2;
        }else if(jugador==7){
            posicion=pos_medio_3;
        }else if(jugador==8){
            posicion=pos_medio_4;
        }else if(jugador==9){
            posicion=pos_delantero_1;
        }else{
            posicion=pos_delantero_2;
        }
        return posicion;
    }
    private int mioCercanoPos(Point punto){
        int jugador=0;
        double distancia=320;
        double distanciaA=0;
        jugador=mioCercanoPos_NoPortero(punto);
        distanciaA=distancia(obtenerPosicion(jugador),punto);
        if(distanciaA<distancia){
            distancia=distanciaA;
        }
        distanciaA=distancia(pos_portero,punto);
        if(distanciaA<distancia){
            jugador=0;
            distancia=distanciaA;
        }
        return jugador;
    }
    private int mioCercanoSigPos(Point bola,int pasos){
        Point sig=siguientePosicionBola(bola,pasos);
        return mioCercanoPos(sig);
    }
    private int mioCercanoSigPos(Point bola){
        return mioCercanoSigPos(bola,1);
    }
}